Intense short-period internal waves in the ocean

Trains of quasi-periodic high-frequency internal waves (IWs) of large amplitude are common in the upper thermocline of the ocean. Sources for these waves may be different ones but it is not always possible to experimentally establish them for certain. We analyzed results of many IW experiments carried out in different representative regions of the World Ocean, including continental margins in the Mid-Atlantic Bight, in the northwestern Pacific at Kamchatka, the Seyshelles-Mascarene bottom rise, and some regions of the open ocean where the intense short-period IWs occur. Comparative analysis of the intense IWs observed in the Mid-Atlantic Bight and at Kamchatka revealed similarity and difference in the IW field in these regions differing by their bottom topography. Most of the observed trains in the Mid-Atlantic Bight propagate shoreward from the shelf break in the form of soliton packets or solibores and do not occur seaward from the shelf. The soliton trains in the northwestern Pacific at Kamchatka are common not only at the shelf edge but also in deep water where they propagate in various directions that seem to be related to the supercritical steepness and complicated form of the continental slope. Observation of generation and evolution of the IW trains at the Seyshelles-Mascarene bottom rise where huge internal solitons have been encountered has shown that the undular bore generated at the lee side of the bottom rise gradually evolves in a train of solitons with the trailing linear waves. Large solitons are generated also in deep water as a result of ray propagation of the internal tide emanated from the rise as happens in the Bay of Biscay. Certain consequences of the IW interaction with the background current leading to intensification of the high-frequency waves were observed in several regions of the open ocean. Revealed dependency of the intense wave propagation direction on the current direction, and closeness of the wave frequency to the frequency at which the waveguide steeply tapers may be regarded as clear evidences for the important role which currents play in the IW intensification

CUP: Comprehensive User-Space Protection for C/C++

Memory corruption vulnerabilities in C/C++ applications enable attackers to execute code, change data, and leak information. Current memory sanitizers do no provide comprehensive coverage of a program's data. In particular, existing tools focus primarily on heap allocations with limited support for stack allocations and globals. Additionally, existing tools focus on the main executable with limited support for system libraries. Further, they suffer from both false positives and false negatives. We present Comprehensive User-Space Protection for C/C++, CUP, an LLVM sanitizer that provides complete spatial and probabilistic temporal memory safety for C/C++ program on 64-bit architectures (with a prototype implementation for x86_64). CUP uses a hybrid metadata scheme that supports all program data including globals, heap, or stack and maintains the ABI. Compared to existing approaches with the NIST Juliet test suite, CUP reduces false negatives by 10x (0.1%) compared to the state of the art LLVM sanitizers, and produces no false positives. CUP instruments all user-space code, including libc and other system libraries, removing them from the trusted code base

Detailed Heap Profiling

Modern software systems heavily use the memory heap. As systems grow more complex and compute with increasing amounts of data, it can be difficult for developers to understand how their programs actually use the bytes that they allocate on the heap and whether improvements are possible. To answer this question of heap usage efficiency, we have built a new, detailed heap profiler called Memoro. Memoro uses a combination of static instrumentation, subroutine interception, and runtime data collection to build a clear picture of exactly when and where a program performs heap allocation, and crucially how it actually uses that memory. Memoro also introduces a new visualization application that can distill collected data into scores and visual cues that allow developers to quickly pinpoint and eliminate inefficient heap usage in their software. Our evaluation and experience with several applications demonstrates that Memoro can reduce heap usage and produce runtime improvements of 10%

Understanding GCC Builtins to Develop Better Tools

C programs can use compiler builtins to provide functionality that the C language lacks. On Linux, GCC provides several thousands of builtins that are also supported by other mature compilers, such as Clang and ICC. Maintainers of other tools lack guidance on whether and which builtins should be implemented to support popular projects. To assist tool developers who want to support GCC builtins, we analyzed builtin use in 4,913 C projects from GitHub. We found that 37% of these projects relied on at least one builtin. Supporting an increasing proportion of projects requires support of an exponentially increasing number of builtins; however, implementing only 10 builtins already covers over 30% of the projects. Since we found that many builtins in our corpus remained unused, the effort needed to support 90% of the projects is moderate, requiring about 110 builtins to be implemented. For each project, we analyzed the evolution of builtin use over time and found that the majority of projects mostly added builtins. This suggests that builtins are not a legacy feature and must be supported in future tools. Systematic testing of builtin support in existing tools revealed that many lacked support for builtins either partially or completely; we also discovered incorrect implementations in various tools, including the formally verified CompCert compiler

Threadsanitizer: data race detection in practice

Data races are a particularly unpleasant kind of threading bugs. They are hard to find and reproduce – you may not observe a bug during the entire testing cycle and will only see it in production as rare unexplainable failures. This paper presents ThreadSanitizer – a dynamic detector of data races. We describe the hybrid algorithm (based on happensbefore and locksets) used in the detector. We introduce what we call dynamic annotations – a sort of race detection API that allows a user to inform the detector about any tricky synchronization in the user program. Various practical aspects of using ThreadSanitizer for testing multithreaded C++ code at Google are also discussed

Data-Flow/Dependence Profiling for Structured Transformations

International audienceProfiling feedback is an important technique used by developers for performance debugging, where it is usually used to pinpoint performance bottlenecks and also to find optimization opportunities. Assessing the validity and potential benefit of a program transformation requires accurate knowledge of the data flow and dependencies, which can be uncovered by profiling a particular execution of the program. In this work we develop poly-prof, an end-to-end infrastructure for dynamic binary analysis, which produces feedback about the potential to apply complex program rescheduling. Our tool can handle both inter-and intraproce-dural aspects of the program in a unified way, thus providing interprocedural transformation feedback